# -*- coding: utf-8 -*-
# @Time    : 2024/6/14 11:21
# @Author  : yujiahao
# @File    : 23_os_sys_time_random.py
# @description:Python中的几个模块:os、sys、hashilib、collentions


# TODO 1、 os模块是与操作系统交互的一个接口,它提供的功能多与工作目录，路径，文件等相关

# 导入os 模块
import os


# 获取和修改当前工作目录
def get_and_change_working_directory():
    """
    获取当前工作目录并修改它，然后恢复到初始目录。
    """
    # 获取当前工作目录
    current_working_directory = os.getcwd()
    print(f"当前工作目录: {current_working_directory}")

    # 改变当前工作目录到 /tmp
    os.chdir('/tmp')
    print(f"改变后的工作目录: {os.getcwd()}")

    # 返回当前目录的符号 .

    print(f"当前目录符号: {os.curdir}")

    '''在当前目录下创建tesr.txt并写入文件'''

    filename = os.path.join(os.curdir, 'test.txt')
    with open(filename, 'w') as f:
        f.write('This is a test file.')

    # 返回当前目录的父目录符号 ..
    print(f"父目录符号: {os.pardir}")

    # 恢复到初始工作目录
    os.chdir(current_working_directory)
    print(f"恢复后的工作目录: {os.getcwd()}")


# 文件夹相关操作
def directory_operations():
    """
    进行文件夹的创建、删除和列出目录内容的操作。
    """
    # 创建多层递归目录
    try:
        os.makedirs('testdir1/testdir2', exist_ok=True)
        print("创建多层递归目录: testdir1/testdir2")
    except Exception as e:
        print(f"创建目录时发生错误: {e}")

    # 删除多层递归空目录
    try:
        os.removedirs('testdir1/testdir2')
        print("删除多层递归目录: testdir1/testdir2")
    except Exception as e:
        print(f"删除目录时发生错误: {e}")

    # 创建单级目录
    try:
        os.mkdir('testdir')
        print("创建单级目录: testdir")
    except FileExistsError:
        print("目录 testdir 已存在。")
    except Exception as e:
        print(f"创建目录时发生错误: {e}")

    # 删除单级空目录
    try:
        os.rmdir('testdir')
        print("删除单级空目录: testdir")
    except OSError:
        print("目录 testdir 不是空的，无法删除。")
    except Exception as e:
        print(f"删除目录时发生错误: {e}")

    # 列出当前目录下的所有文件和子目录
    try:
        files_and_dirs = os.listdir('.')
        print(f"当前目录内容: {files_and_dirs}")
    except Exception as e:
        print(f"列出目录内容时发生错误: {e}")


# 文件相关操作
def file_operations(path):
    """
    进行文件的创建、删除、重命名和获取文件信息的操作。
    """
    # 创建文件并写入内容
    '''标准的 open 函数不会自动创建不存在的目录，可以使用 os.makedirs 函数来确保目录存在，然后再创建和写入文件。'''
    try:
        with open('test.txt', 'w') as f:
            f.write('测试os模块!')
        print("创建文件: test.txt 并写入内容")
    except Exception as e:
        print(f"创建文件时发生错误: {e}")

    # 删除文件
    try:
        os.remove('testfile.txt')
        print("删除文件: testfile.txt")
    except FileNotFoundError:
        print("文件 testfile.txt 不存在，无法删除。")
    except Exception as e:
        print(f"删除文件时发生错误: {e}")

    # 创建文件并重命名
    try:
        with open('oldname.txt', 'w') as f:
            f.write('Hello, World!')
        os.rename('oldname.txt', 'newname.txt')
        print("重命名文件: oldname.txt -> newname.txt")
    except FileNotFoundError:
        print("文件 oldname.txt 不存在，无法重命名。")
    except Exception as e:
        print(f"重命名文件时发生错误: {e}")

    # 获取文件信息
    try:
        # 获取文件状态信息
        stat_info = os.stat(path)

        # 打印文件状态信息
        print(f"文件路径: {path}")
        print(f"文件大小: {stat_info.st_size} 字节")
        print(f"最后访问时间: {stat_info.st_atime}")
        print(f"最后修改时间: {stat_info.st_mtime}")
        print(f"文件创建时间: {stat_info.st_ctime}")
        print(f"文件权限: {stat_info.st_mode}")
    except FileNotFoundError:
        print(f"文件或目录 {path} 不存在")


# 路径相关操作
def path_operations(current_fire_name):
    """
    进行路径的获取、分割、判断和组合操作。
    """
    # 返回文件的绝对路径
    abs_path = os.path.abspath(current_fire_name)
    print(f"绝对路径: {abs_path}")

    '''将路径拆分为目录部分和文件名部分。它返回一个包含两个元素的元组：第一个元素是路径的目录部分，第二个元素是路径的文件名部分'''
    dir_name, file_name = os.path.split(abs_path)
    print(f"目录名: {dir_name}, 文件名: {file_name}")

    # 返回路径的目录部分
    print(f"目录名: {os.path.dirname(abs_path)}")

    # 返回路径的文件名部分
    print(f"文件名: {os.path.basename(abs_path)}")

    # 判断路径是否存在
    print(f"路径存在: {os.path.exists(abs_path)}")

    # 判断是否为绝对路径
    print(f"是否为绝对路径: {os.path.isabs(abs_path)}")

    # 判断是否为文件
    print(f"是否为文件: {os.path.isfile(abs_path)}")

    # 判断是否为目录
    print(f"是否为目录: {os.path.isdir(abs_path)}")

    # 将多个路径组合后返回
    combined_path = os.path.join('/home/user', 'documents', 'file.txt')
    print(f"组合路径: {combined_path}")

    # 获取文件的最后访问时间
    print(f"最后访问时间: {os.path.getatime(abs_path)}")

    # 获取文件的最后修改时间
    print(f"最后修改时间: {os.path.getmtime(abs_path)}")

    # 获取文件大小
    print(f"文件大小: {os.path.getsize(abs_path)} 字节")


# 操作系统相关操作
def os_operations():
    """
    获取操作系统相关的信息并执行系统命令。
    """
    # 输出操作系统特定的路径分隔符
    print(f"路径分隔符: {os.sep}")

    # 输出当前平台使用的行终止符
    print(f"行终止符: {os.linesep}")

    # 输出用于分割文件路径的字符串
    print(f"路径分割符: {os.pathsep}")

    # 输出字符串指示当前使用平台
    print(f"操作系统名称: {os.name}")

    # 运行shell命令，直接显示
    os.system("echo 'Hello, World!'")

    # 运行shell命令，获取执行结果
    result = os.popen("echo 'Hello, World!'").read()
    print(f"命令输出: {result}")

    # 获取系统环境变量
    path_env = os.environ.get('PATH')
    print(f"PATH 环境变量: {path_env}")


# 文件/目录信息的结构说明
def file_info_structure(file_name):
    """
    获取文件/目录的信息并详细解释各个属性。
    """
    try:
        # 获取文件信息
        file_info = os.stat(file_name)
        print(f"文件信息: {file_info}")

        # 详细的文件状态信息
        print(f"文件模式: {file_info.st_mode}")
        # 文件模式表示文件的类型和权限。可以使用 oct() 函数将其转换为八进制字符串以便于阅读。

        print(f"i-node 号: {file_info.st_ino}")
        # i-node 号是文件系统中唯一标识文件的编号。每个文件都有一个唯一的 i-node 号。

        print(f"设备号: {file_info.st_dev}")
        # 设备号表示文件所在设备的标识符。对于在同一文件系统中的文件，此值通常是相同的。

        print(f"硬链接数: {file_info.st_nlink}")
        # 硬链接数表示指向该文件的硬链接数量。每个文件至少有一个硬链接（文件名本身）。

        print(f"所有者用户 ID: {file_info.st_uid}")
        # 表示文件所有者的用户 ID。可以使用 pwd 模块将用户 ID 转换为用户名。

        print(f"所有者组 ID: {file_info.st_gid}")
        # 表示文件所有者的组 ID。可以使用 grp 模块将组 ID 转换为组名。

        print(f"文件大小（字节）: {file_info.st_size}")
        # 文件的大小，以字节为单位。对于目录，此值通常为 4096 字节（即 4 KB），但这取决于文件系统的实现。

        print(f"最后访问时间: {file_info.st_atime}")
        # 文件的最后访问时间。表示上次读取文件内容的时间。使用 time.ctime() 将其转换为可读的时间格式。

        print(f"最后修改时间: {file_info.st_mtime}")
        # 文件内容的最后修改时间。表示上次修改文件内容的时间。使用 time.ctime() 将其转换为可读的时间格式。

        print(f"最后状态变化时间: {file_info.st_ctime}")
        # 文件状态的最后变化时间（例如权限修改）。使用 time.ctime() 将其转换为可读的时间格式。

    except FileNotFoundError:
        print(f"文件或目录 '{file_name}' 不存在")
        # 处理文件或目录不存在的情况。

    except Exception as e:
        print(f"获取文件信息时发生错误: {e}")
        # 处理其他可能的异常。


# todo 2、sys 模块是 Python 标准库中的一个模块，提供了一些与 Python 解释器和系统相关的功能。

# 导入模块
import sys


def my_sys():
    """
    演示 sys 模块的常用功能。
    """

    # 命令行参数
    # sys.argv 是一个列表，其中包含命令行参数
    # 第一个元素是程序本身的路径
    print("命令行参数列表 (sys.argv):", sys.argv)
    if len(sys.argv) > 1:
        print("第一个参数:", sys.argv[1])
    else:
        print("没有提供额外的命令行参数。")

    # 解释器相关信息
    # sys.version 返回 Python 解释器的版本信息
    print("Python 版本 (sys.version):", sys.version)
    # sys.platform 返回操作系统平台名称
    print("操作系统平台 (sys.platform):", sys.platform)

    # 模块搜索路径
    # sys.path 是一个列表，包含了 Python 查找模块的路径
    # 这些路径在初始化时使用 PYTHONPATH 环境变量的值
    print("模块搜索路径 (sys.path):", sys.path)

    # 获取对象大小
    # sys.getsizeof() 返回对象的大小（以字节为单位）
    print("对象 'hello' 的大小:", sys.getsizeof("hello"))

    # 异常处理
    # sys.exc_info() 返回当前正在处理的异常的类型、值和追溯信息
    try:
        1 / 0  # 这会引发一个 ZeroDivisionError 异常
    except ZeroDivisionError:
        exc_type, exc_value, exc_traceback = sys.exc_info()
        print("异常类型:", exc_type)
        print("异常值:", exc_value)
        print("异常追溯:", exc_traceback)

    # 标准输入输出流
    # sys.stdin 是标准输入流，默认连接到键盘输入
    # sys.stdout 是标准输出流，默认连接到控制台
    print("请输入一些文本:")
    input_text = sys.stdin.readline().strip()  # 从标准输入读取一行，并去掉末尾的换行符
    print("你输入的是:", input_text)

    # 退出程序,你执行当前文件的时候外部传进来的参数，比如 python 23_os_sys_time_random.py  exit  这个exit会被传进来判断
    # sys.exit() 退出程序，状态码为 0 表示成功退出，非零表示异常退出
    if len(sys.argv) > 1:
        if sys.argv[1] == 'exit':
            print("程序即将正常退出")
            sys.exit(0)  # 正常退出
        elif sys.argv[1] == 'error':
            print("程序即将错误退出")
            sys.exit(1)  # 错误退出


# todo 3、time 模块主要用于处理与时间相关的操作，如获取当前时间、暂停程序执行、测量时间间隔等。它更侧重于处理时间戳和与系统时间相关的操作。


"""
在 Python 的 time 模块中，时间可以表示为以下三种主要形式：

1. 时间戳（Timestamp）：
   - 时间戳是一个浮点数，表示从1970年1月1日00:00:00 UTC（称为Unix纪元）以来的秒数。时间戳通常用于时间的存储和计算，因为它是一个单一的、连续的值。
   - 示例：time.time() 返回当前时间的时间戳。

2. 结构化时间（struct_time）：
   - struct_time 是一个表示时间的结构体，包含 9 个字段，分别表示年、月、日、时、分、秒、星期几、一年中的第几天和是否为夏令时。
   - 示例：time.localtime() 和 time.gmtime() 返回当前时间的 struct_time 对象。

3. 格式化时间字符串（Formatted Time String）：
   - 格式化时间字符串是一个字符串，表示特定格式的时间。它通常用于显示时间或与用户交互。
   - 示例：time.strftime() 将 struct_time 对象格式化为字符串，time.strptime() 将时间字符串解析为 struct_time 对象。

python中时间日期格式化符号： 

    %y 两位数的年份表示（00-99） 
    %Y 四位数的年份表示（000-9999） 
    %m 月份（01-12） 
    %d 月内中的一天（0-31） 
    %H 24小时制小时数（0-23） 
    %I 12小时制小时数（01-12） 
    %M 分钟数（00=59） 
    %S 秒（00-59） 
    %a 本地简化星期名称 
    %A 本地完整星期名称 
    %b 本地简化的月份名称 
    %B 本地完整的月份名称 
    %c 本地相应的日期表示和时间表示 
    %j 年内的一天（001-366） 
    %p 本地A.M.或P.M.的等价符 
    %U 一年中的星期数（00-53）星期天为星期的开始 
    %w 星期（0-6），星期天为星期的开始 
    %W 一年中的星期数（00-53）星期一为星期的开始 
    %x 本地相应的日期表示 
    %X 本地相应的时间表示 
    %Z 当前时区的名称 
    %% %号本身

"""

import time


def time_module_operations():
    # 获取当前时间戳
    current_time = time.time()
    print("当前时间戳:", current_time)

    # 将时间戳转换为 struct_time 对象
    local_time = time.localtime(current_time)
    print("本地时间:", local_time)

    # 将时间戳转换为 UTC 的 struct_time 对象
    utc_time = time.gmtime(current_time)
    print("UTC 时间:", utc_time)

    # 格式化时间
    formatted_time = time.strftime("%Y-%m-%d %H:%M:%S", local_time)
    print("格式化的本地时间:", formatted_time)

    # 解析时间字符串
    time_string = "2024-06-14 14:23:45"
    parsed_time = time.strptime(time_string, "%Y-%m-%d %H:%M:%S")
    print("解析后的时间:", parsed_time)

    # 将时间字符串转化为时间戳

    print("将格式化的时间转为时间戳：", time.mktime(parsed_time))

    # 暂停程序执行
    print("程序暂停 2 秒...")
    time.sleep(2)
    print("程序继续执行。")

    # 测量时间间隔
    start_time = time.time()
    # 执行一些操作
    time.sleep(2)
    end_time = time.time()
    print("操作耗时:", end_time - start_time, "秒")

    # 获取 CPU 时间
    cpu_time = time.process_time()
    print("当前进程的 CPU 时间:", cpu_time)

    # struct_time 对象的结构
    print("struct_time 对象结构示例:", local_time)


# todo 4、datetime 模块提供了更高级和更灵活的日期和时间处理功能。它可以处理日期、时间、时间间隔等，并且支持时区转换。


from datetime import datetime, timedelta, timezone


def datetime_module_operations():
    # 指定datetime时间

    # 获取当前时间
    current_time = datetime.now()
    print("当前时间:", current_time)

    # 调整到1977年
    adjusted_time_year = current_time.replace(year=1977)
    print("调整到1977年:", adjusted_time_year)

    # 调整到1月份
    adjusted_time_month = current_time.replace(month=1)
    print("调整到1月份:", adjusted_time_month)

    # 调整到1989年4月25日
    adjusted_time_full = current_time.replace(year=1989, month=4, day=25)
    print("调整到1989年4月25日:", adjusted_time_full)

    # 获取当前日期和时间
    now = datetime.now()
    print("当前日期和时间:", now)

    # 获取当前 UTC 日期和时间
    utc_now = datetime.utcnow()
    print("当前 UTC 日期和时间:", utc_now)

    # 创建特定日期和时间
    specific_date = datetime(2024, 6, 14, 14, 30, 0)
    print("特定日期和时间:", specific_date)

    # 格式化日期和时间
    formatted_date = now.strftime("%Y-%m-%d %H:%M:%S")
    print("格式化的日期和时间:", formatted_date)

    # 解析日期和时间字符串
    date_string = "2024-06-14 14:30:00"
    parsed_date = datetime.strptime(date_string, "%Y-%m-%d %H:%M:%S")
    print("解析后的日期和时间:", parsed_date)

    # 日期和时间运算
    tomorrow = now + timedelta(days=1)
    print("明天的这个时间:", tomorrow)

    # 处理时区
    utc_now = datetime.now(timezone.utc)
    print("当前 UTC 时间:", utc_now)

    # 转换为其他时区
    cst = timezone(timedelta(hours=8))
    cst_time = utc_now.astimezone(cst)
    print("转换为 CST 时间:", cst_time)

    # 时间戳转datetime对象

    # 时间戳
    timestamp = 1505107800.0

    # 转换
    dt = datetime.fromtimestamp(timestamp)
    print("时间戳转为 datetime 对象:", dt)

    # datetime对象转时间戳

    # datetime 对象
    dt = datetime(2017, 9, 11, 8, 30, 0)

    # 转换
    timestamp = dt.timestamp()
    print("datetime 对象转为时间戳:", timestamp)


# todo 5、random 模块用于生成伪随机数，如果遇到需要随机的需求：随机验证码，发红包等等。


import random


def random_operations(operation):
    """
    根据传入的操作名称返回对应的随机操作函数。

    参数:
        operation (str): 要执行的随机操作的名称。

    返回:
        function: 对应的随机操作函数。
    """

    # 生成随机浮点数 [0.0, 1.0)
    def generate_random_float():
        return random.random()

    # 生成指定范围内的随机浮点数
    def generate_uniform_float(a, b):
        return random.uniform(a, b)

    # 生成指定范围内的随机整数
    def generate_random_int(a, b):
        return random.randint(a, b)

    # 生成指定范围内的随机整数，步长为 step
    def generate_randrange(start, stop, step):
        return random.randrange(start, stop, step)

    # 从序列中随机选择一个元素
    def random_choice(seq):
        return random.choice(seq)

    # 从序列中随机选择多个元素（不重复）
    def random_sample(seq, k):
        return random.sample(seq, k)

    # 从序列中随机选择多个元素（可重复）
    def random_choices(seq, k):
        return random.choices(seq, k=k)

    # 打乱序列
    def shuffle_list(seq):
        random.shuffle(seq)
        return seq

    # 设置随机种子
    '''随机种子是用于初始化随机数生成器的一个数值，通过设置随机种子，可以确保每次运行程序时生成的随机数序列相同。
    这在调试、测试、科学研究和实验等场景中非常有用，可以帮助确保结果的可重复性和可验证性。
    
    不同种子值的区别：seed

        - 不同的种子值会初始化随机数生成器到不同的起始状态，从而生成不同的随机数序列。
        - 相同的种子值在不同的运行中会生成相同的随机数序列，确保可重复性。
        - 不同的种子值在不同的运行中会生成不同的随机数序列，确保随机性。
    应用场景：

        - 相同种子值：用于调试、测试和验证，以确保结果的可重复性。
        - 不同种子值：用于生成不同的随机数据，确保数据的多样性和随机性。
    
    '''

    def set_seed(seed):
        random.seed(seed)
        return random.random()

    # 生成正态分布的随机数
    """
    正态分布（Normal Distribution），也称为高斯分布（Gaussian Distribution），
    是一种非常重要的连续概率分布，在统计学和概率论中有着广泛的应用。
    它的概率密度函数（PDF）呈钟形曲线，具有对称性，且其形状由两个参数决定：均值（μ）和标准差（σ）。

    主要特征：
    1. 对称性：正态分布是关于均值 μ 对称的，均值 μ 是分布的中心位置。
    2. 钟形曲线：正态分布的概率密度函数呈钟形，曲线在均值 μ 处达到最高点。
    3. 68-95-99.7 规则：
       - 约68%的数据位于均值 μ ± 1个标准差 σ 之间。
       - 约95%的数据位于均值 μ ± 2个标准差 σ 之间。
       - 约99.7%的数据位于均值 μ ± 3个标准差 σ 之间。

    概率密度函数：
    正态分布的概率密度函数（PDF）定义如下：
    f(x | μ, σ) = (1 / (σ * sqrt(2π))) * exp(-((x - μ)^2) / (2σ^2))

    其中：
    - x 是随机变量。
    - μ 是均值。
    - σ 是标准差。
    - exp 是指数函数。

    标准正态分布：
    标准正态分布是均值为0、标准差为1的特殊正态分布，通常用 Z 表示，其概率密度函数为：
    f(z) = (1 / sqrt(2π)) * exp(-z^2 / 2)

    应用场景：
    正态分布在许多领域中有着广泛的应用，包括但不限于：
    1. 自然科学和工程：很多自然现象，如人的身高、血压、测量误差等，通常都近似服从正态分布。
    2. 金融和经济学：资产回报率、市场价格波动等常常假设为正态分布。
    3. 统计学：许多统计方法和理论，如假设检验、回归分析等，基于正态分布的假设。

    图示：
    正态分布的概率密度函数图通常如下所示：

            ^
            |                           .--.
            |                        .-`    `-.
            |                     .-`          `-.
            |                   .`                `.
            |                 .`                    `.
            |                /                        \
            |               /                          \
            |              /                            \
            |             /                              \
            |            /                                \
            |           /                                  \
            |          /                                    \
            |         /                                      \
            |        /                                        \
            |       /                                          \
            |      /                                            \
            |     /                                              \
            |    /                                                \
            |   /                                                  \
            |  /                                                    \
            | /                                                      \
            |/                                                        \
            +---------------------------------------------------------->

    总结：
    正态分布是统计学中最重要的分布之一，其对称钟形曲线由均值和标准差决定。
    正态分布在自然科学、工程、金融、经济学等多个领域都有广泛应用，是许多统计方法和理论的基础。
    
    这个函数的作用是生成一个符合正态分布的随机数，接受两个参数：
    mu (𝜇)：均值，决定正态分布的中心位置。
    sigma (𝜎)：标准差，决定正态分布的宽度（即数据的离散程度）。
    """

    def generate_gauss(mu, sigma):
        return random.gauss(mu, sigma)

    # 生成指数分布的随机数

    """
    指数分布（Exponential Distribution）是一种连续概率分布，
    通常用于描述事件发生的时间间隔。它在统计学和概率论中有着广泛的应用，
    特别是在排队论、可靠性工程和生物统计学等领域。指数分布是无记忆性的，
    这意味着未来的事件发生时间与过去无关。

    概率密度函数（PDF）：
    f(x | λ) = λ e^(-λ x)  for x >= 0

    其中：
    - x 是随机变量，表示时间间隔。
    - λ 是速率参数（rate parameter），也称为事件发生率或强度。
    - e 是自然对数的底数（约等于 2.71828）。

    累积分布函数（CDF）：
    F(x | λ) = 1 - e^(-λ x)  for x >= 0

    特性：
    1. 无记忆性：
       指数分布具有无记忆性，即对于任意 s, t >= 0，满足：
       P(X > s + t | X > s) = P(X > t)
       这意味着如果我们已经等待了时间 s，再等待时间 t 的概率与从头开始等待时间 t 的概率是相同的。

    2. 均值和方差：
       - 均值（期望值）： E(X) = 1 / λ
       - 方差： Var(X) = 1 / λ^2

    3. 应用场景：
       - 排队论：描述顾客到达服务窗口的时间间隔。
       - 可靠性工程：描述设备的故障时间间隔。
       - 生物统计学：描述生物体的寿命。

    示例：
    假设我们有一个电话呼叫中心，平均每分钟接到 λ = 2 个电话。
    我们想知道下一次电话呼叫到达的时间间隔。

    在这种情况下，时间间隔 X 服从参数为 λ = 2 的指数分布。

    使用 Python 生成符合指数分布的随机数：

    import random

    # 定义 λ 参数
    lambd = 2.0

    # 生成一个符合 λ = 2 的指数分布随机数
    time_interval = random.expovariate(lambd)
    print(time_interval)
    """

    def generate_expovariate(lambd):
        return random.expovariate(lambd)

    # 生成指定比特数的随机整数
    """
    生成指定比特数的随机整数：
    函数 `getrandbits(k)` 是 Python `random` 模块中的一个函数，
    用于生成一个具有指定比特数的随机整数。

    参数：
    - k：指定生成的随机整数的比特数。

    返回：
    - 返回一个具有 k 比特的随机整数。

    应用场景：
    - 用于需要高随机性和特定比特长度的场景，例如加密密钥生成、uuid、随机标识符生成等。
    """

    def getrandbits(k):
        return random.getrandbits(k)

    # 练习：生成随机验证码。

    def v_code():
        code = ''
        for i in range(5):
            num = random.randint(0, 9)
            alf = chr(random.randint(65, 90))
            add = random.choice([num, alf])
            code = "".join([code, str(add)])

        return code

    # 操作字典，将操作名称映射到对应的函数
    operations = {
        "generate_random_float": generate_random_float,
        "generate_uniform_float": generate_uniform_float,
        "generate_random_int": generate_random_int,
        "generate_randrange": generate_randrange,
        "random_choice": random_choice,
        "random_sample": random_sample,
        "random_choices": random_choices,
        "shuffle_list": shuffle_list,
        "set_seed": set_seed,
        "generate_gauss": generate_gauss,
        "generate_expovariate": generate_expovariate,
        "getrandbits": getrandbits,
        "v_code": v_code
    }

    # 返回对应的函数，如果操作名称无效则返回一个提示函数
    return operations.get(operation, lambda: "Invalid operation")


def main():
    # 生成随机浮点数 [0.0, 1.0)
    print("随机浮点数 [0.0, 1.0):", random_operations("generate_random_float")())

    # 生成指定范围内的随机浮点数
    print("随机浮点数 [1.5, 5.5]:", random_operations("generate_uniform_float")(1.5, 5.5))

    # 生成指定范围内的随机整数
    print("随机整数 [1, 10]:", random_operations("generate_random_int")(1, 10))

    # 生成指定范围内的随机整数，步长为 2
    print("随机整数 [1, 10) 步长为 2:", random_operations("generate_randrange")(1, 10, 2))

    # 从序列中随机选择一个元素
    print("随机选择一个元素:", random_operations("random_choice")(['apple', 'banana', 'cherry']))

    # 从序列中随机选择多个元素（不重复）
    print("随机选择三个元素（不重复）:",
          random_operations("random_sample")(['apple', 'banana', 'cherry', 'date', 'fig'], 3))

    # 从序列中随机选择多个元素（可重复）
    print("随机选择五个元素（可重复）:", random_operations("random_choices")(['apple', 'banana', 'cherry'], 5))

    # 打乱序列
    items = [1, 2, 3, 4, 5]
    print("打乱后的列表:", random_operations("shuffle_list")(items))

    # 设置随机种子
    print("设置种子后的随机数:", random_operations("set_seed")(42))

    # 生成正态分布的随机数
    print("正态分布 (mu=0, sigma=1):", random_operations("generate_gauss")(0, 1))

    # 生成指数分布的随机数
    print("指数分布 (lambda=1.5):", random_operations("generate_expovariate")(1.5))

    # 生成指定比特数的随机整数
    print("随机布尔值 (1 比特随机整数):", random_operations("getrandbits")(1))
    # 生成随机验证码
    print("生成随机验证码:", random_operations("v_code")())


if __name__ == "__main__":
    main()
